// 任务服务
import { getPrisma } from '../config/prisma.ts';

// 定义任务类型
interface Task {
  task_id: number;
  group_id: number;
  title: string;
  description?: string;
  is_important: boolean;
  is_my_day: boolean;
  status: number;
  completed_at?: string | null;
  due_date?: string | null;
  created_at: string;
  updated_at?: string;
}

// 定义任务更新结果类型
interface TaskUpdateResult {
  task_id: number;
  group_id: number;
  updated_at: string;
}

/**
 * 创建任务服务
 * 处理创建新任务的业务逻辑
 * @param {number} userId - 用户ID
 * @param {number} groupId - 任务分组ID
 * @param {string} title - 任务标题
 * @param {string} description - 任务描述
 * @param {boolean} isImportant - 是否重要
 * @param {boolean} isMyDay - 是否标记为"我的一天"
 * @param {string} dueDate - 截止日期
 * @returns {Promise<Task>} 创建的任务数据
 */
async function createTask(
  userId: number, 
  groupId: number | 1, 
  title: string, 
  description?: string, 
  isImportant: boolean = false, 
  isMyDay: boolean = false, 
  dueDate: string | null = null
): Promise<Task> {
  try {
    const prismaClient = await getPrisma();
    console.log('正在为用户创建任务:', userId);
    
    // 1. 验证输入
    if (!title) {
      throw new Error('任务标题是必需的');
    }
    
    // 2. 在数据库中创建任务
    const task = await prismaClient.task.create({
      data: {
        userId: BigInt(userId),
        groupId: groupId ? BigInt(groupId) : 1,
        title: title,
        description: description || null,
        isImportant: isImportant,
        isMyDay: isMyDay,
        dueDate: dueDate ? new Date(dueDate) : null
      }
    });
    
    console.log('任务创建成功，ID:', Number(task.id));
    
    // 3. 返回任务数据
    return {
      task_id: Number(task.id),
      group_id: Number(task.groupId),
      title: task.title,
      description: task.description || '',
      is_important: task.isImportant,
      is_my_day: task.isMyDay,
      status: task.status,
      due_date: task.dueDate ? task.dueDate.toISOString() : null,
      created_at: task.createdAt.toISOString()
    };
  } catch (error) {
    console.error('任务服务中的数据库操作失败:', (error as Error).message);
    throw error;
  }
}

/**
 * 获取任务列表服务
 * 处理获取用户任务列表的业务逻辑
 * @param {number} userId - 用户ID
 * @param {number|null} groupId - 任务分组ID（可选）
 * @param {number|null} status - 任务状态（可选）
 * @returns {Promise<Task[]>} 任务列表
 */
async function getTasks(
  userId: number, 
  groupId: number | string | undefined = undefined, 
  status: number | string | undefined = undefined
): Promise<Task[]> {
  try {
    const prismaClient = await getPrisma();
    console.log('正在从数据库获取用户任务:', userId);
    
    // 1. 构建查询条件
    const whereClause: any = {
      userId: BigInt(userId),
      deletedAt: null
    };
    
    if (groupId) {
      whereClause.groupId = BigInt(groupId);
    }
    
    // 仅在status是有效数字时添加状态条件
    const statusValue = parseInt(status as string, 10);
    if (!isNaN(statusValue)) {
      whereClause.status = {
        equals: statusValue
      };
    }
    
    // 2. 从数据库获取任务
    const tasks = await prismaClient.task.findMany({
      where: whereClause,
      orderBy: {
        createdAt: 'desc'
      }
    });
    
    console.log('找到', tasks.length, '个任务，用户:', userId);
    
    // 3. 返回任务数据
    return tasks.map((task: any) => ({
      task_id: Number(task.id),
      group_id: Number(task.groupId),
      title: task.title,
      description: task.description,
      is_important: task.isImportant,
      is_my_day: task.isMyDay,
      status: task.status,
      completed_at: task.completedAt ? task.completedAt.toISOString() : null,
      due_date: task.dueDate ? task.dueDate.toISOString() : null,
      created_at: task.createdAt.toISOString(),
      updated_at: task.updatedAt.toISOString()
    }));
  } catch (error) {
    console.error('任务服务中的数据库操作失败:', (error as Error).message);
    throw error;
  }
}

/**
 * 获取"我的一天"任务服务
 * 处理获取用户标记为"我的一天"的任务列表的业务逻辑
 * @param {number} userId - 用户ID
 * @returns {Promise<Task[]>} "我的一天"任务列表
 */
async function getMyDayTasks(userId: number): Promise<Task[]> {
  try {
    const prismaClient = await getPrisma();
    console.log('正在从数据库获取"我的一天"任务，用户:', userId);
    
    // 1. 从数据库获取"我的一天"任务
    const tasks = await prismaClient.task.findMany({
      where: {
        userId: BigInt(userId),
        isMyDay: true,
        deletedAt: null
      },
      orderBy: {
        createdAt: 'desc'
      }
    });
    
    console.log('找到', tasks.length, '个"我的一天"任务，用户:', userId);
    
    // 2. 返回任务数据
    return tasks.map((task: any) => ({
      task_id: Number(task.id),
      group_id: Number(task.groupId),
      title: task.title,
      description: task.description,
      is_important: task.isImportant,
      is_my_day: task.isMyDay,
      status: task.status,
      completed_at: task.completedAt ? task.completedAt.toISOString() : null,
      due_date: task.dueDate ? task.dueDate.toISOString() : null,
      created_at: task.createdAt.toISOString(),
      updated_at: task.updatedAt.toISOString()
    }));
  } catch (error) {
    console.error('任务服务中的数据库操作失败:', (error as Error).message);
    throw error;
  }
}

/**
 * 获取任务详情服务
 * 处理获取特定任务详情的业务逻辑
 * @param {number} userId - 用户ID
 * @param {number} taskId - 任务ID
 * @returns {Promise<Task>} 任务详情
 */
async function getTaskDetail(userId: number, taskId: number): Promise<Task> {
  try {
    const prismaClient = await getPrisma();
    console.log('正在从数据库获取任务详情。用户:', userId, '任务ID:', taskId);
    
    // 1. 查找任务
    const task = await prismaClient.task.findFirst({
      where: {
        id: BigInt(taskId),
        userId: BigInt(userId),
        deletedAt: null
      }
    });
    
    if (!task) {
      throw new Error('任务未找到或访问被拒绝');
    }
    
    console.log('任务详情获取成功');
    
    // 2. 返回任务数据
    return {
      task_id: Number(task.id),
      group_id: Number(task.groupId),
      title: task.title,
      description: task.description || '',
      is_important: task.isImportant,
      is_my_day: task.isMyDay,
      status: task.status,
      completed_at: task.completedAt ? task.completedAt.toISOString() : null,
      due_date: task.dueDate ? task.dueDate.toISOString() : null,
      created_at: task.createdAt.toISOString(),
      updated_at: task.updatedAt.toISOString()
    };
  } catch (error) {
    console.error('任务服务中的数据库操作失败:', (error as Error).message);
    throw error;
  }
}

/**
 * 更新任务服务
 * 处理更新任务信息的业务逻辑
 * @param {number} userId - 用户ID
 * @param {number} taskId - 任务ID
 * @param {number} groupId - 任务分组ID
 * @param {string} title - 任务标题
 * @param {string} description - 任务描述
 * @param {boolean} isImportant - 是否重要
 * @param {boolean} isMyDay - 是否标记为"我的一天"
 * @param {number} status - 任务状态
 * @param {string} dueDate - 截止日期
 * @returns {Promise<Task>} 更新后的任务数据
 */
async function updateTask(
  userId: number, 
  taskId: number, 
  groupId: number | undefined, 
  title: string | undefined, 
  description: string | undefined, 
  isImportant: boolean | undefined, 
  isMyDay: boolean | undefined, 
  status: number | undefined, 
  dueDate: string | undefined
): Promise<Task> {
  try {
    const prismaClient = await getPrisma();
    console.log('正在数据库中更新任务。用户:', userId, '任务ID:', taskId);
    
    // 1. 检查任务是否存在且属于用户
    const task = await prismaClient.task.findFirst({
      where: {
        id: BigInt(taskId),
        userId: BigInt(userId),
        deletedAt: null
      }
    });
    
    if (!task) {
      throw new Error('任务未找到或访问被拒绝');
    }
    
    // 2. 准备更新数据
    const updateData: any = {};
    if (groupId !== undefined) updateData.groupId = BigInt(groupId);
    if (title !== undefined) updateData.title = title;
    if (description !== undefined) updateData.description = description;
    if (isImportant !== undefined) updateData.isImportant = isImportant;
    if (isMyDay !== undefined) updateData.isMyDay = isMyDay;
    if (status !== undefined) updateData.status = status;
    if (dueDate !== undefined) updateData.dueDate = dueDate ? new Date(dueDate) : null;
    
    // 3. 更新数据库中的任务
    const updatedTask = await prismaClient.task.update({
      where: {
        id: BigInt(taskId)
      },
      data: updateData
    });
    
    console.log('任务更新成功');
    
    // 4. 返回更新后的任务数据
    return {
      task_id: Number(updatedTask.id),
      group_id: Number(updatedTask.groupId) ,
      title: updatedTask.title,
      description: updatedTask.description || '',
      is_important: updatedTask.isImportant,
      is_my_day: updatedTask.isMyDay,
      status: updatedTask.status,
      completed_at: updatedTask.completedAt ? updatedTask.completedAt.toISOString() : null,
      due_date: updatedTask.dueDate ? updatedTask.dueDate.toISOString() : null,
      created_at: updatedTask.createdAt.toISOString(),
      updated_at: updatedTask.updatedAt.toISOString()
    };
  } catch (error) {
    console.error('任务服务中的数据库操作失败:', (error as Error).message);
    throw error;
  }
}

/**
 * 删除任务服务
 * 处理删除任务的业务逻辑
 * @param {number} userId - 用户ID
 * @param {number} taskId - 任务ID
 * @returns {Promise<void>} 无返回值
 */
async function deleteTask(userId: number, taskId: number): Promise<void> {
  try {
    const prismaClient = await getPrisma();
    console.log('正在数据库中删除任务。用户:', userId, '任务ID:', taskId);
    
    // 1. 检查任务是否存在且属于用户
    const task = await prismaClient.task.findFirst({
      where: {
        id: BigInt(taskId),
        userId: BigInt(userId),
        deletedAt: null
      }
    });
    
    if (!task) {
      throw new Error('任务未找到或访问被拒绝');
    }
    
    // 2. 软删除数据库中的任务
    await prismaClient.task.update({
      where: {
        id: BigInt(taskId)
      },
      data: {
        deletedAt: new Date()
      }
    });
    
    console.log('任务删除成功');
  } catch (error) {
    console.error('任务服务中的数据库操作失败:', (error as Error).message);
    throw error;
  }
}

/**
 * 更新任务分组服务
 * 处理更新任务所属分组的业务逻辑
 * @param {number} userId - 用户ID
 * @param {number} taskId - 任务ID
 * @param {number} groupId - 新的任务分组ID
 * @returns {Promise<TaskUpdateResult>} 更新后的任务数据
 */
async function updateTaskGroup(userId: number, taskId: number, groupId: number): Promise<TaskUpdateResult> {
  try {
    const prismaClient = await getPrisma();
    console.log('正在数据库中更新任务分组。用户:', userId, '任务ID:', taskId);
    
    // 1. 检查任务是否存在且属于用户
    const task = await prismaClient.task.findFirst({
      where: {
        id: BigInt(taskId),
        userId: BigInt(userId),
        deletedAt: null
      }
    });
    
    if (!task) {
      throw new Error('任务未找到或访问被拒绝');
    }
    
    // 2. 更新数据库中的任务分组
    const updatedTask = await prismaClient.task.update({
      where: {
        id: BigInt(taskId)
      },
      data: {
        groupId: BigInt(groupId)
      }
    });
    
    console.log('任务分组更新成功');
    
    // 3. 返回更新后的任务数据
    return {
      task_id: Number(updatedTask.id),
      group_id: Number(updatedTask.groupId),
      updated_at: updatedTask.updatedAt.toISOString()
    };
  } catch (error) {
    console.error('任务服务中的数据库操作失败:', (error as Error).message);
    throw error;
  }
}

export default { createTask, getTasks, getMyDayTasks, getTaskDetail, updateTask, deleteTask, updateTaskGroup };



